/*
    isEventNumber   判断 是不是 偶数函数 
        @param number num 输入判断的数据
        @return boolean 返回判断结果

    对输入的数据进行判断 如果是 偶数返回值是 true 如果不是偶数返回值是 false
    输入的数据只要可以自动转化为数值类型就可以
    如果不能转化返回报错信息

*/ 
function isEventNumber(num){
    // 强制转化为数值类型
    num = Number(num);

    // 如果是 NaN 执行 报错
    if( isNaN( num ) ){
        return '您输入的数据格式有误';
    }

    // 执行判断
    if( num % 2 === 0 ){
        return true ;
    }else{
        return false ;
    }
}


/*
    isLeapYear 判断是不是闰年
        @param number year 输入的判断的年份
        @return boolean 判断结果 
    
    对输入的年份进行判断 如果是 闰年返回值是 true 如果不是闰年返回值是 false
    输入的年份必须是可以自动转化为数值类型


*/ 
function isLeapYear(year){
    // 强制转化为数值类型
    year = Number(year);

    // 如果是NaN 报错
    if( isNaN( year ) ){
        return '您输入的年份数据类型有误';
    }

    // 判断是不是闰年
    if( (year % 400 === 0) || ( (year % 4 === 0) && (year % 100 !== 0) ) ){
        return true ;
    }else{
        return false;
    }
}

/*
    factorial   求输入数值的阶乘
        @param number num 输入求阶乘的数值
        @return number res 阶乘结果

    对输入的数据求阶乘结果
    输入的数据必须是可以自动转化为数值类型    

*/

function factorial(num){
    // 强制转化为数值类型
    num = Number(num);

    // 如果是NaN 报错
    if( isNaN( num ) ){
        return '您输入的年份数据类型有误';
    }

    // 定义变量储存阶乘结果
    var res = 1;
    for( var i = 1 ; i <= num ; i++ ){
        res *= i ;
    }

    return res ;
}


/*
    isPrimeNumber 判断质数函数
        @param number num 输入的需要判断的数值
        @return boolean 判断的结果

    对输入的数据判断是不是质数 
    输入的数据必须可以自动转化为数值类型

*/ 
function isPrimeNumber(num){
    // 强制转化为数值类型
    num = Number(num);

    // 如果是NaN 报错
    if( isNaN( num ) ){
        return '您输入的年份数据类型有误';
    }

    // for( var i = 2 ; i <= num / 2 ; i++ ){
    //     // 如果整除 证明 num 是 合数 
    //     // 触发 return 返回 false
    //     // 循环之外 的 return true 不会执行
    //     if( num % i === 0 ){
    //         return false;
    //     }
    // }
    // // 如果循环中没有触发 整除 没有触发 return false
    // // 执行 循环外 的 return true 证明 数值是一个 质数
    // return true ; 


    var bool = true ; 
    for( var i = 2 ; i <= num / 2 ; i++ ){
        if( num % i === 0 ){
            bool = false;
            break
        }
    }
    return bool ;
}


/*

    isNarcissisticNumber    判断是不是水仙花数
        @param  number num 输入的需要判断的数值
        @return boolean 判断的结果

    对输入的数据判断是不是水仙花数 
    输入的数据必须可以自动转化为数值类型

*/

function isNarcissisticNumber(num){
    // 强制转化为数值类型
    num = Number(num);

    // NaN 和 NaN 永远结果是 不等
    // 不能使用 NaN === NaN 来判断
    if( isNaN( num ) ){
        return '您输入的数据格式有误';
    }

    // 获取每一位上的数值
    a = parseInt( num / 100 );
    b = parseInt( ( num % 100 ) / 10 );
    c = num % 10 ;

    // 进行判断
    if( a*a*a + b*b*b + c*c*c === num ){
        return true;
    }else{
        return false;
    }
}


/*
    setRGB 随机颜色rgb
        @return string 返回的是rgb() 格式的随机颜色字符串

*/
function setRGB(){
    // 随机数的范围是 0 - 255
    // 公式是 parseInt( Math.random() * ( 255 + 1 - 0 ) + 0 )
    // 公式是 parseInt( Math.random() * 256 )
    return `rgb(${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)})` ;

}


/*
    setRGB 随机颜色rgba
        @return string 返回的是rgba() 格式的随机颜色字符串

*/
function setRGBA(){
    // 随机数的范围是 0 - 255
    // 公式是 parseInt( Math.random() * ( 255 + 1 - 0 ) + 0 )
    // 公式是 parseInt( Math.random() * 256 )

    // 透明度的范围是 0 - 1 的 一位小数
    // 0 - 10 的整数 / 10 结果就是 0 - 1 的 一位小数
    // 0 - 10 的随机数值公式
    // parseInt( Math.random() * ( 10 + 1 - 0 ) + 0 )
    // parseInt( Math.random() * 11 )

    return `rgba(${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)} , ${ parseInt(Math.random() * 11) / 10 })` ;                                
 
}

/*
    isPalindromeString 判断回文字符串
        @param string str 需要判断的字符串
        @return boolean 判断的结果

    对输入的数据判断是不是回文字符串
*/

function isPalindromeString(str){
    // 将输入的数据 强制转化为字符串类型
    // str = String( str );
    // str = str.toString(); 
    // 通过拼接空字符串 自动转化为字符串类型
    // 不影响原始内容
    str = str + '' ; 

    // 将字符串中的每一个字符 都转化为数组单元
    var arr = str.split('');

    // 数组反转
    // 数组是引用数据类型
    // 比较判断的 内存地址 结果永远是 不相等
    arr.reverse();

    // 反转的数组 拼接为字符串
    var newStr = arr.join('');

    // 如果 新字符串 和 原始字符串 相等
    // 是 回文字符串
    if( newStr ===  str){
        return true;
    }else{
        return false;
    }
}


/*
    数组去重方法1 indexOf方法
        @param array arr 输入的需要去重的数组
*/ 

function getNewArr1(arr){
    // 创建一个新数组
    var newArr = [] ;

    // 循环遍历 原始数组
    // for( var i = 0 ; i <= arr.length-1 ; i++ ){
    //     // i 是 索引下标
    //     // arr[i] 是 数组的数据

    //     // 使用 indexOf() 查询
    //     // 查看 新数组中 有没有 要写入的 原始数组的数据 arr[i]
    //     // newArr.indexOf( arr[i] ) 的结果如果是 -1 
    //     // 证明 新数组newArr中 没有 要写入的 arr[i]
    //     // 此时 可以执行写入操作
    //     if( newArr.indexOf( arr[i] ) === -1 ){
    //         // 将 原始数组的数据 arr[i] 写入 新数组 newArr 中
    //         newArr.push( arr[i] )
    //     }
    // }

    // // for..in 循环 index 变量 存储 索引下标
    // for( var index in arr ){
    //     if( newArr.indexOf( arr[index] ) === -1 ){        
    //         newArr.push( arr[index] )
    //     }
    // }


    // for..of 循环 value 变量 存储 索引下标
    // for( var value of arr ){
    //     if( newArr.indexOf( value ) === -1 ){        
    //         newArr.push( value );
    //     }
    // }

    // forEach 循环 参数1 存储 数值
    arr.forEach(function(item){
        if( newArr.indexOf( item ) === -1 ){
            newArr.push( item );
        }
    })

    return newArr ;
}


/*
    getVC   获取随机验证码 
        @param  number  length  验证码长度 字符个数     默认值是 6
        @param  string  str     验证码内容             默认值是 小写 大写英文字母 0-9数字 
        @param  boolean bool    验证码内容是否重复      默认值是 false 表示 字符可以重复 

        @return string  vc      返回生成的验证码内容
*/ 

function getVC( length = 6 , str = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' , bool = false ){
    var vc = '';

    if (bool) {
        // bool 如果是 true 表示 验证码内容 不能重复
        while( true ){
            // 定义变量 存储随机索引下标
            var index = parseInt( Math.random() * str.length );

            // 判断 验证码字符串中没有当前字符 再拼接
            if( vc.indexOf( str[index] ) === -1 ){
                vc += str[index];
            }
            
            if (vc.length === length) {
                break ;
            }
        }   
    }else{
        // bool 如果是 false 表示 验证码内容 可以重复
        while( true ){
            // 直接向验证码字符串拼接写入字符
            vc += str[ parseInt( Math.random() * str.length ) ];

            if (vc.length === length) {
                break ;
            }
        }   
    }
    return vc ;            
}

/*
    myGetDate   获取时间数据
        @param  string  timeString   表示要获取时间数据的字符串
        @return object  获取的时间对象的数据

        如果输入参数 获取参数对应的时间数据
        如果不输入参数 获取当前时间的时间数据

*/
function myGetDate( timeString ){
            
    if( timeString === undefined ){
        // 形参存储 undefined 证明 没有实参输入
        // 默认值获取 当前时间的时间对象
        var time = new Date();

    }else{
        // 形参存储 不是 undefined 证明 有实参输入
        // 获取实参对应的时间数据
        var time = new Date( timeString );
    }


    var year = time.getFullYear();

    var month = time.getMonth()+1; 

    var day = time.getDate();
    
    var weekArr = ['星期日' , '星期一' , '星期二' , '星期三' , '星期四' , '星期五' , '星期六'];
    var week = weekArr[ time.getDay() ];

    var hours = time.getHours();
    var minutes = time.getMinutes();
    var seconds = time.getSeconds();

    return {
        year : year , 
        month : month , 
        day : day , 
        week : week , 
        hours : hours , 
        minutes : minutes , 
        seconds : seconds , 
    } ;            
}

/*
    myGetCountDown  获取倒计时时间对象
        @param  string  end 倒计时时间字符串
        @return object  倒计时时间对象结果 

*/
function myGetCountDown( end ){
    var endTime = new Date(end);
    var startTime = new Date();

    var time = parseInt( ( endTime.getTime() - startTime.getTime() ) / 1000 );

    var d = parseInt( time / (24*60*60) );
    var h = parseInt( ( time % (24*60*60) ) / (60*60) );
    var m = parseInt( ( time % (60*60) ) / 60 );
    var s = time % 60 ;

    return { d , h , m , s } ;            
}


/*
    myGetUrlValue  获取浏览器地址栏数据
        @return object obj 浏览器地址栏数据键值 转化的对象
*/ 

function myGetUrlValue(){
    // 1 获取浏览器地址栏数据 去除第一个?问号
    var str = window.location.search.substr( 1 );

    // 2 将字符串按照 '&' 分割为数组
    var arr1 = str.split('&');

    // 3 定义一对象,存储转化结果
    var obj = {} ;

    // 4 循环遍历数组 将数组单元按照=等号 转化为数组
    arr1.forEach(function(item){
        var arr2 = item.split('=');

        // arr2[0] 是 键名 arr2[1] 是 键值
        // 存储进对象 

        if( obj[ arr2[0] ] === undefined ){
            // 证明 对象中 没有这个键名和数据 直接存储
            // %加十六进制 还原为对应的 中文等
            obj[ arr2[0] ] = window.decodeURIComponent( arr2[1] );

        }else{
            // 证明 对象中 已经有这个键名了

            // 调用数据的数据类型如果 是数组
            if( typeof( obj[ arr2[0] ] ) === 'object' ){
                // 数组中新增数据单元
                // %加十六进制 还原为对应的 中文等
                obj[ arr2[0] ].push( window.decodeURIComponent( arr2[1] ) );

            // 调用数据的数据类型如果 不是数组
            // 键名存储一个数组 数组的第一个单元是原始数据 第二个单元是新数组
            // %加十六进制 还原为对应的 中文等
            }else{
                obj[ arr2[0] ] = [ obj[ arr2[0] ] , window.decodeURIComponent( arr2[1] ) ];
            }
        }
    })
    
    // 返回这个对象
    return obj ;
}